/*
 * Vec2D.cpp
 *
 *  Created on: Jun 24, 2012
 *      Author: burek
 */

#include "Vec2D.h"
#include "Vec3D.h"
#include <cmath>

const Vec2D Vec2D::Zero(0.0f, 0.0f);
const Vec2D Vec2D::One(1.0f, 1.0f);

const Vec2D Vec2D::XUnit(1.0f, 0.0f);
const Vec2D Vec2D::YUnit(0.0f, 1.0f);

const Vec2D Vec2D::NegXUnit(-1.0f, 0.0f);
const Vec2D Vec2D::NegYUnit(0.0f, -1.0f);

Vec2D::Vec2D( void ) { X = 0.0f; Y = 0.0f; }
Vec2D::Vec2D( const float x, const float y )
{ X = x; Y = y; }

Vec2D& Vec2D::operator= ( const Vec2D& A )
{ X = A.X; Y = A.Y; return *this; }

bool Vec2D::operator== ( const Vec2D& A ) const
{ return X == A.X && Y == A.Y; }

bool Vec2D::operator!= ( const Vec2D& A ) const
{ return X != A.X || Y != A.Y; }

Vec2D Vec2D::operator+ ( const Vec2D& A ) const
{ return Vec2D( X + A.X, Y + A.Y ); }

Vec2D Vec2D::operator- ( const Vec2D& A ) const
{ return Vec2D( X - A.X, Y - A.Y ); }

Vec2D Vec2D::operator* ( const Vec2D& A ) const
{ return Vec2D( X * A.X, Y * A.Y ); }

Vec2D Vec2D::operator/ ( const Vec2D& A ) const
{ return Vec2D( X / A.X, Y / A.Y ); }

Vec2D Vec2D::operator* ( const float A ) const
{ return Vec2D( X * A, Y * A ); }

Vec2D Vec2D::operator/ ( const float A ) const
{ return Vec2D( X / A, Y / A ); }

float Vec2D::dot( const Vec2D& A ) const
{ return A.X*X + A.Y*Y; }

float Vec2D::length( void ) const
{ return sqrt(X * X + Y * Y); }

float Vec2D::lengthSquared( void ) const
{ return (X * X + Y * Y); }

void Vec2D::set(float x, float y)
{
	X = x;
	Y = y;
}

Vec2D Vec2D::normalize(void) const
{
	float len = length();
	if(len != 0.0f)
		return Vec2D(X / len, Y / len);
	else
		return *this;
}

float Vec2D::distanceTo(const Vec2D& A) const
{
	float dX = A.X - X, dY = A.Y - Y;
	return sqrt(dX * dX + dY * dY);
}

float Vec2D::distanceSquared(const Vec2D& A) const
{
	float dX = A.X - X, dY = A.Y - Y;
	return (dX * dX + dY * dY);
}

void Vec2D::normalizeIP(void)
{
	float len = length();
	X = X / len; Y = Y / len;
}

void Vec2D::operator += ( const Vec2D& A )
{ X += A.X; Y += A.Y; }

void Vec2D::operator *= ( const Vec2D& A )
{ X *= A.X; Y *= A.Y; }

void Vec2D::operator /= ( const Vec2D& A )
{ X /= A.X; Y /= A.Y; }

void Vec2D::operator -= ( const Vec2D& A )
{ X -= A.X; Y -= A.Y; }

void Vec2D::operator *= ( const float A )
{ X *= A; Y *= A; }

void Vec2D::operator /= ( const float A )
{ X /= A; Y /= A; }

void Vec2D::lerpIP( const Vec2D& A, const float x )
{ X += (A.X - X) * x; Y += (A.Y - Y) * x; }

Vec2D Vec2D::lerp( const Vec2D& A, const float x ) const
{ return Vec2D(X + (A.X - X) * x, Y + (A.Y - Y) * x); }


